#include<iostream>
#include<cstdio>
#include<cstdlib>//获取环境变量
#include<cstring>
#include<unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;


const int basesize = 1024;
const int argvnum = 64;

//全局的命令行参数列表
char* gargv[argvnum];
int gargc = 0;//计数器

// 全局的变量  最近一次对应的数值
int lastcode = 0;

// 我的系统的环境变量
char *genv[envnum];

// 全局的当前shell工作路径 
char pwd[basesize];
char pwdenv[basesize];

string GetUserName()
{
  string name = getenv("USER");//getenv获取信息
  return name.empty? "None": name;
}

string GetHostName()
{
  string hostname = getenv("HOSTNAME");
  return hostname.empty? "None": hostname;
}

string GetPwd()
{
   //获取路径从系统里获取 getcwd获取路径是从shell里获取的
    if(nullptr == getcwd(pwd, sizeof(pwd))) return "None";
    snprintf(pwdenv, sizeof(pwdenv),"PWD=%s", pwd);//当改变路径是，shell的环境变量也需要改变,将坏境变量放到pwdenv中
    putenv(pwdenv); // PWD=XXX；putenv将环境变量导出
    return pwd;  
  
  //string pwd = getenv("PWD")；
 // return pwd.empty? "None": pwd;  
  
}

string LastDir()//获取最后的路径，而不是获取很长的路径
{
    string curr = GetPwd();
    if(curr == "/" || curr == "None") return curr;
    // /home/whb/XXX
    size_t pos = curr.rfind("/");
    if(pos == std::string::npos) return curr;
    return curr.substr(pos+1);
}

string MakeCommandLine()//将上述的组合在一起像 [whb@bite-alicloud myshell]$  的格式
{
    char command_line[basesize];
    snprintf(command_line, basesize, "[%s@%s %s]# ",\
            GetUserName().c_str(), GetHostName().c_str(), LastDir().c_str());
    return command_line;
}


void PrintCommandLine() // 命令行提示符
{
    printf("%s", MakeCommandLine().c_str());//打印上述的组合
    fflush(stdout);
}

bool GetCommandLine(char command_buffer[], int size)   // 获取用户命令
{
  // 我们认为：我们要将用户输入的命令行，当做一个完整的字符串
 // "ls -a -l -n"
    char *result = fgets(command_buffer, size, stdin);//输入命令
    if(!result)
    {
        return false;
    }
    command_buffer[strlen(command_buffer)-1] = 0;//这样写可以去掉默认的\n；\n是在回车之后的下一个
    if(strlen(command_buffer) == 0) return false;//如果没有这一行，在解析命令时输入回车argc会是1;家伙是那个这一行，输入回车不会执行解析命令
    return true;  
}

void ParseCommandLine(char command_buffer[], int len) //解析命令ls -a -b -c -d 分别进行分析
{
  (void)len;
  memset(gargv, 0, sizeof(gargv));//每次执行的时候需要清空
  gargc = 0;     
  
  // "ls -a -l -n"将输入的命令拆分；strtok就是按照空格拆分；拆分完之后写一个nullptr
    const char *sep = " ";
    gargv[gargc++] = strtok(command_buffer, sep);
    
    // =是刻意写的
    while((bool)(gargv[gargc++] = strtok(nullptr, sep)));//继续拆分
    gargc--;//为nullptr的时候还执行了一次；所以要--；
}


// 在shell中
// 有些命令，必须由子进程来执行
// 有些命令，不能由子进程执行，要由shell自己执行 --- 内建命令 built command
  bool ExecuteCommand()   // 4. 执行命令
{
    // 让子进程进行执行
    pid_t id = fork();
    if(id < 0) return false;
    if(id == 0)
    {
        //子进程
        // 1. 执行命令
        execvpe(gargv[0], gargv, genv);//gargv[0]表示在这个路径下，否则不会走到这一步
        // 2. 退出
        exit(1);
    }
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if(rid > 0)
    {
        if(WIFEXITED(status))
        {
            lastcode = WEXITSTATUS(status);
        }
        else
        {
            lastcode = 100;
        }
        return true;
    }
    return false;
}
·


void AddEnv(const char *item)//坏境变量导入系统
{
    int index = 0;
    while(genv[index])//找到坏境变量为空的位置
    {
        index++;
    }

    genv[index] = (char*)malloc(strlen(item)+1);//   /0
    strncpy(genv[index], item, strlen(item)+1);
    genv[++index] = nullptr;
}


//检查是否是内建命令
// shell自己执行命令，本质是shell调用自己的函数
bool CheckAndExecBuiltCommand()
{
  //cd就是内建命令；shell路径会被子进程继承
  if(strcmp(gargv[0], "cd") == 0)
    {
        // 内建命令
        if(gargc == 2)
        {
            chdir(gargv[1]);//0是cd 1是..;路径切换
            lastcode = 0;
 
       }
        else
        {
            lastcode = 1;
        }
        return true;
    }
  else if(strcmp(gargv[0], "export") == 0)
    {
        // export也是内建命令
        if(gargc == 2)
        {
            AddEnv(gargv[1]);
            lastcode = 0;
        }
        else
        {
            lastcode = 2;
        }
        return true;
    }
    else if(strcmp(gargv[0], "env") == 0)
    {
        for(int i = 0; genv[i]; i++)
        {
            printf("%s\n", genv[i]);
        }
        lastcode = 0;
        return true;
    }
    else if(strcmp(gargv[0], "echo") == 0)
    {
        if(gargc == 2)
        {
            // echo $?
            // echo $PATH
            // echo hello
            if(gargv[1][0] == '$')
            {
                if(gargv[1][1] == '?')
                {
                    printf("%d\n", lastcode);
                    lastcode = 0;
                }
            }
            else
            {
                printf("%s\n", gargv[1]);
                lastcode = 0;
            }
        }
        else
        {
            lastcode = 3;
        }
        return true;
    }
    return false;
}




// 作为一个shell，获取环境变量应该从系统的配置来
// 我们今天就直接从父进程shell中获取环境变量
void InitEnv()
{
    extern char **environ;
    int index = 0;
    while(environ[index])
    {
        genv[index] = (char*)malloc(strlen(environ[index])+1);//	先创建空间
        strncpy(genv[index], environ[index], strlen(environ[index])+1);//从父进程遍历获取（environ）->getenv
        index++;
    }
    genv[index] = nullptr;
}


int main()
{
  InitEnv();
  char command_buffer[basesize];
  while(true)//一直执行
  {
   PrintCommandLine();//命令提示符

  if (!GetCommandLine(command_buffer,basesize))//获取用户命令
  {
      continue;
  }
  //printf("%s\n",command_buffer);

  ParseCommandLine(command_buffer,strlen(command_buffer));//分析命令

   if ( CheckAndExecBuiltCommand() )//判断是否是内建命令；即shell执行的还是子进程执行的；如果是则继续，否则下一步ExecuteCommnad()
        {
            continue;
        }


  ExecuteCommnad();//执行命令

  return 0;
}
